package com.boxuegu.service;

import com.boxuegu.dao.UserDao;
import com.boxuegu.domain.User;
import com.boxuegu.domain.Fruit;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;

public class UserService {
    // 创建UserDao对象，以供使用
    private UserDao userDao = new UserDao();
    private ArrayList<User> users;
    private ArrayList<Fruit> fruits;

    public UserService() throws IOException {
    }


    // 判断用户序号是否存在方法
    public boolean isExists(String id) throws IOException, ClassNotFoundException {
        // 获取全部用户对象集合
        users = userDao.findAllUser();
        // 先假设用户id不存在
        boolean exists = false;
        // 遍历集合获取每一个用户对象用于判断
        if (users != null) {
            for (User user : users) {
                if (user.getId().equals(id)) {
                    exists = true;
                    break;
                }
            }
        }
        return exists;
    }

    // 登录判断方法
    public boolean checkPassword(String id, String password) throws IOException, ClassNotFoundException {
        // 获取全部用户集合
        users = userDao.findAllUser();
        // 先假设登录失败
        boolean flag = false;
        // 遍历集合
        if (users != null) {
            for (User user : users) {
                // 判断接收的id密码是否与集合中的任意一个对象的id密码匹配
                if (user.getId().equals(id) && user.getPassword().equals(password)) {
                    //匹配则登陆成功结束循环
                    flag = true;
                    break;
                }
            }
        }
        return flag;
    }

    // 获取全部水果信息方法
    public ArrayList<Fruit> findAllFruit() throws IOException, ClassNotFoundException {
        return userDao.findAllFruit();
    }

    // 获取余额方法
    public double getMoney(String id) throws IOException, ClassNotFoundException {
        double money = 0;
        users = userDao.findAllUser();
        if (users != null) {
            for (User user : users) {
                // 判断接收的id是否与集合中的任意一个对象的id密码匹配
                if (user.getId().equals(id)) {
                    money = user.getMoney();
                    break;
                }
            }
        }
        return money;
    }

    // 判断水果名是否存在
    public boolean isFruitExists(String fruitName) {
        // 获取全部水果对象集合
        try {
            fruits = userDao.findAllFruit();
        } catch (IOException e) {
            e.printStackTrace();
        }
        // 先假设水果名不匹配
        boolean exists = false;
        // 判断集合不为空
        if (fruits != null) {
            // 遍历集合
            for (Fruit fruit : fruits) {
                // 判断接受的水果名是否与任意水果对象名匹配
                if (fruit.getName().equals(fruitName)) {
                    // 匹配返回true结束循环
                    exists = true;
                    break;
                }
            }
        }
        return exists;

    }

    // 获取水果数量
    public double getFruitAmount(String fruitName) {
        try {
            fruits = userDao.findAllFruit();
        } catch (IOException e) {
            e.printStackTrace();
        }
        double amount = 0;
        if (fruits != null) {
            for (Fruit fruit : fruits) {
                if (fruit.getName().equals(fruitName)) {
                    amount = fruit.getAmount();
                    break;
                }
            }
        }
        return amount;
    }

    // 将用户购买的水果名称和数量添加至购物车，并将购物车返回
    public HashMap<Fruit, Integer> addFruitToShoppingBasket(String fruitName, int fruitNumber, HashMap<Fruit, Integer> shopCat) throws IOException {
        fruits = userDao.findAllFruit();
        // 定义根据用户购买信息匹配到的水果对象
        Fruit buyFruit = null;
        if (fruits != null) {
            for (Fruit fruit : fruits) {
                // 遍历获取匹配的水果对象结束循环
                if (fruit.getName().equals(fruitName)) {
                    buyFruit = fruit;
                    break;
                }
            }
        }
        // 如果集合为空则从未存入，直接存入即可，否则判断新存入购物车的水果信息是否已经存入过
        if (shopCat != null) {
            // 获取购物车集合中键的集合
            Set<Fruit> fruitsSet = shopCat.keySet();
            // 遍历集合
            for (Fruit fruit1 : fruitsSet) {
                // 判断是否与存入过得水果名称相同，
                if (fruit1.getName().equals(fruitName)) {
                    //相同则将购物车中的水果的数量与新增数量相加
                    fruitNumber += shopCat.get(fruit1);
                    break;
                }
            }
            shopCat.put(buyFruit, fruitNumber);
        } else {
            shopCat.put(buyFruit, fruitNumber);
        }
        return shopCat;
    }

    // 获取购物车中水果总价
    public double getPriceSum(HashMap<Fruit, Integer> cat) {
        Set<Fruit> fruits = cat.keySet();
        double sum = 0;
        for (Fruit fruit : fruits) {
            sum = sum + (fruit.getPrice() * cat.get(fruit));
        }
        // 返回总价
        return sum;
    }

    // 获取购物车中水果折扣总价
    public double getPriceDiscountSum(HashMap<Fruit, Integer> cat) {
        // 获取总价
        double priceSum = getPriceSum(cat);
        // 定义折扣后价格
        double discountSum;
        if (priceSum >= 100 && priceSum <= 200) {
            // 100-200 超过100部分9折
            discountSum = 100 + (priceSum - 100) * 0.9;
        } else if (priceSum > 200 && priceSum <= 500) {
            // 小于等于500 100-200之间9折 200-500八折
            discountSum = 100 + 100 * 0.9 + (priceSum - 200) * 0.8;
        } else if (priceSum > 500) {
            // 大于500 100-200之间9折 200-500八折 大于500部分7折
            discountSum = 100 + 100 * 0.9 + 300 * 0.8 + (priceSum - 500) * 0.7;
        } else {
            // 小于100 不打折
            discountSum = priceSum;
        }
        return discountSum;
    }

    // 用户购买商品，余额减少
    public void pay(String id, double discountSum, HashMap<Fruit, Integer> cat) throws IOException, ClassNotFoundException {
        //获取所有用户数据
        ArrayList<User> users = userDao.findAllUser();
        //遍历集合找到当前用户
        for (int i = 0; i < users.size(); i++) {
            if (users.get(i).getId().equals(id)) {
                //修改其余额
                double result = users.get(i).getMoney() - discountSum;
                users.get(i).setMoney(result);
                break;
            }
        }
        //调用userDao中的方法将更新后的集合写出到文本中
        userDao.outputInUserFile(users);
        //获取购物车中所有水果
        Set<Fruit> catFruits = cat.keySet();
        //获取文本中所有水果数据
        ArrayList<Fruit> fruits = userDao.findAllFruit();
        //遍历集合找到与购物车中匹配的水果并将库存修改
        for (int i = 0; i < fruits.size(); i++) {
            for (Fruit catFruit : catFruits) {
                if (catFruit.getName().equals(fruits.get(i).getName())) {
                    int result2 =
                            fruits.get(i).getAmount()
                                    - cat.get(catFruit);
                    fruits.get(i).setAmount(result2);
                    break;
                }
            }
        }
        //调用userDao中的方法将更新后的集合写出到文本中
        userDao.outputInFruitFile(fruits);
        return;
    }
    //获取购物车中水果的数量
    public int getValue(String fruitName, HashMap<Fruit, Integer> cat) throws IOException {
        // 定义根据用户购买信息匹配到的水果对象
        Fruit catFruit = null;
        // 获取购物车集合中键的集合
        Set<Fruit> fruitsSet = cat.keySet();
        // 遍历集合
        for (Fruit fruit1 : fruitsSet) {
            // 判断是否与存入过得水果名称相同，
            if (fruit1.getName().equals(fruitName)) {
                //相同则将购物车中的水果记录
               catFruit = fruit1;
                break;
            }
        }
        if (catFruit != null){
            return cat.get(catFruit);
        }
        return 0;
    }
}